// 文本转换工具的组合式函数
import CryptoJS from 'crypto-js'

// 标签页配置
export const tabs = [
  { id: 'case', name: '大小写转换', icon: '🔤', placeholder: '输入要转换大小写的文本...' },
  { id: 'escape', name: '转义/反转义', icon: '🔒', placeholder: '输入要转义或反转义的文本...' },
  { id: 'encode', name: '编码/解码', icon: '🔐', placeholder: '输入要编码或解码的文本...' },
  { id: 'number', name: '数字处理', icon: '🔢', placeholder: '输入包含数字的文本...' },
  { id: 'sort', name: '排序', icon: '📊', placeholder: '输入要排序的文本行...' },
  { id: 'align', name: '对齐', icon: '📐', placeholder: '输入要对齐的文本...' },
  { id: 'filter', name: '过滤/清理', icon: '🧹', placeholder: '输入要过滤清理的文本...' },
  { id: 'other', name: '其他操作', icon: '⚙️', placeholder: '输入要处理的文本...' }
]

// 功能配置
export const functions = [
  // 大小写转换
  { id: 'camelCase', name: 'camelCase', category: 'case' },
  { id: 'pascalCase', name: 'PascalCase', category: 'case' },
  { id: 'snakeCase', name: 'snake_case', category: 'case' },
  { id: 'kebabCase', name: 'kebab-case', category: 'case' },
  { id: 'constantCase', name: 'CONSTANT_CASE', category: 'case' },
  { id: 'dotCase', name: 'dot.case', category: 'case' },
  { id: 'pathCase', name: 'path/case', category: 'case' },
  { id: 'sentenceCase', name: 'Sentence case', category: 'case' },
  { id: 'titleCase', name: 'Title Case', category: 'case' },
  { id: 'upperCase', name: 'UPPERCASE', category: 'case' },
  { id: 'lowerCase', name: 'lowercase', category: 'case' },
  
  // 转义/反转义
  { id: 'escapeJava', name: 'Java转义', category: 'escape' },
  { id: 'unescapeJava', name: 'Java反转义', category: 'escape' },
  { id: 'escapeJavaScript', name: 'JavaScript转义', category: 'escape' },
  { id: 'unescapeJavaScript', name: 'JavaScript反转义', category: 'escape' },
  { id: 'escapeHtml', name: 'HTML转义', category: 'escape' },
  { id: 'unescapeHtml', name: 'HTML反转义', category: 'escape' },
  { id: 'escapeJson', name: 'JSON转义', category: 'escape' },
  { id: 'unescapeJson', name: 'JSON反转义', category: 'escape' },
  { id: 'escapeXml', name: 'XML转义', category: 'escape' },
  { id: 'unescapeXml', name: 'XML反转义', category: 'escape' },
  { id: 'escapeUnicode', name: 'Unicode转义', category: 'escape' },
  { id: 'unescapeUnicode', name: 'Unicode反转义', category: 'escape' },
  
  // 编码/解码
  { id: 'md5', name: 'MD5哈希', category: 'encode' },
  { id: 'sha1', name: 'SHA-1哈希', category: 'encode' },
  { id: 'sha256', name: 'SHA-256哈希', category: 'encode' },
  { id: 'sha512', name: 'SHA-512哈希', category: 'encode' },
  { id: 'base64Encode', name: 'Base64编码', category: 'encode' },
  { id: 'base64Decode', name: 'Base64解码', category: 'encode' },
  { id: 'urlEncode', name: 'URL编码', category: 'encode' },
  { id: 'urlDecode', name: 'URL解码', category: 'encode' },
  { id: 'hexEncode', name: '十六进制编码', category: 'encode' },
  { id: 'hexDecode', name: '十六进制解码', category: 'encode' },
  
  // 数字处理
  { id: 'incrementNumbers', name: '递增数字', category: 'number' },
  { id: 'decrementNumbers', name: '递减数字', category: 'number' },
  { id: 'createSequence', name: '创建序列', category: 'number' },
  
  // 排序
  { id: 'sortAscending', name: '升序排列', category: 'sort' },
  { id: 'sortDescending', name: '降序排列', category: 'sort' },
  { id: 'sortByLength', name: '按长度排序', category: 'sort' },
  { id: 'shuffle', name: '随机打乱', category: 'sort' },
  { id: 'reverse', name: '反转顺序', category: 'sort' },
  { id: 'sortJson', name: 'JSON排序', category: 'sort' },
  
  // 对齐
  { id: 'alignLeft', name: '左对齐', category: 'align' },
  { id: 'alignCenter', name: '居中对齐', category: 'align' },
  { id: 'alignRight', name: '右对齐', category: 'align' },
  
  // 过滤/清理
  { id: 'removeDuplicates', name: '去除重复行', category: 'filter' },
  { id: 'removeEmptyLines', name: '移除空行', category: 'filter' },
  { id: 'trimLines', name: '修剪空格', category: 'filter' },
  { id: 'removeAllSpaces', name: '移除所有空格', category: 'filter' },
  { id: 'compressSpaces', name: '压缩空格', category: 'filter' },
  
  // 其他操作
  { id: 'reverseText', name: '反转文本', category: 'other' },
  { id: 'swapQuotes', name: '交换引号', category: 'other' },
  { id: 'removeLineBreaks', name: '移除换行符', category: 'other' }
]

// 文本处理函数
export const processText = (text, functionId) => {
  if (!text) return ''
  
  switch (functionId) {
    // 大小写转换
    case 'camelCase':
      return toCamelCase(text)
    case 'pascalCase':
      return toPascalCase(text)
    case 'snakeCase':
      return toSnakeCase(text)
    case 'kebabCase':
      return toKebabCase(text)
    case 'constantCase':
      return toConstantCase(text)
    case 'dotCase':
      return toDotCase(text)
    case 'pathCase':
      return toPathCase(text)
    case 'sentenceCase':
      return toSentenceCase(text)
    case 'titleCase':
      return toTitleCase(text)
    case 'upperCase':
      return text.toUpperCase()
    case 'lowerCase':
      return text.toLowerCase()
    
    // 转义/反转义
    case 'escapeJava':
      return escapeJava(text)
    case 'unescapeJava':
      return unescapeJava(text)
    case 'escapeJavaScript':
      return escapeJavaScript(text)
    case 'unescapeJavaScript':
      return unescapeJavaScript(text)
    case 'escapeHtml':
      return escapeHtml(text)
    case 'unescapeHtml':
      return unescapeHtml(text)
    case 'escapeJson':
      return escapeJson(text)
    case 'unescapeJson':
      return unescapeJson(text)
    case 'escapeXml':
      return escapeXml(text)
    case 'unescapeXml':
      return unescapeXml(text)
    case 'escapeUnicode':
      return escapeUnicode(text)
    case 'unescapeUnicode':
      return unescapeUnicode(text)
    
    // 编码/解码
    case 'md5':
      return hashMd5(text)
    case 'sha1':
      return hashSha1(text)
    case 'sha256':
      return hashSha256(text)
    case 'sha512':
      return hashSha512(text)
    case 'base64Encode':
      return btoa(unescape(encodeURIComponent(text)))
    case 'base64Decode':
      try {
        return decodeURIComponent(escape(atob(text)))
      } catch (e) {
        return '解码失败：无效的Base64格式'
      }
    case 'urlEncode':
      return encodeURIComponent(text)
    case 'urlDecode':
      try {
        return decodeURIComponent(text)
      } catch (e) {
        return '解码失败：无效的URL编码格式'
      }
    case 'hexEncode':
      return Array.from(text).map(c => c.charCodeAt(0).toString(16).padStart(2, '0')).join('')
    case 'hexDecode':
      try {
        return text.match(/.{1,2}/g).map(byte => String.fromCharCode(parseInt(byte, 16))).join('')
      } catch (e) {
        return '解码失败：无效的十六进制格式'
      }
    
    // 数字处理
    case 'incrementNumbers':
      return incrementNumbers(text)
    case 'decrementNumbers':
      return decrementNumbers(text)
    case 'createSequence':
      return createSequence(text)
    
    // 排序
    case 'sortAscending':
      return text.split('\n').sort().join('\n')
    case 'sortDescending':
      return text.split('\n').sort().reverse().join('\n')
    case 'sortByLength':
      return text.split('\n').sort((a, b) => a.length - b.length).join('\n')
    case 'shuffle':
      return shuffleArray(text.split('\n')).join('\n')
    case 'reverse':
      return text.split('\n').reverse().join('\n')
    case 'sortJson':
      return sortJson(text)
    
    // 对齐
    case 'alignLeft':
      return alignLeft(text)
    case 'alignCenter':
      return alignCenter(text)
    case 'alignRight':
      return alignRight(text)
    
    // 过滤/清理
    case 'removeDuplicates':
      return [...new Set(text.split('\n'))].join('\n')
    case 'removeEmptyLines':
      return text.split('\n').filter(line => line.trim() !== '').join('\n')
    case 'trimLines':
      return text.split('\n').map(line => line.trim()).join('\n')
    case 'removeAllSpaces':
      return text.replace(/\s/g, '')
    case 'compressSpaces':
      return text.replace(/\s+/g, ' ').trim()
    
    // 其他操作
    case 'reverseText':
      return text.split('').reverse().join('')
    case 'swapQuotes':
      return swapQuotes(text)
    case 'removeLineBreaks':
      return text.replace(/\n/g, ' ')
    
    default:
      return '未知的转换类型'
  }
}

// 辅助函数
function toCamelCase(str) {
  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
    return index === 0 ? word.toLowerCase() : word.toUpperCase()
  }).replace(/\s+/g, '')
}

function toPascalCase(str) {
  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => {
    return word.toUpperCase()
  }).replace(/\s+/g, '')
}

function toSnakeCase(str) {
  return str.replace(/\W+/g, ' ')
    .split(/ |\B(?=[A-Z])/).map(word => word.toLowerCase()).join('_')
}

function toKebabCase(str) {
  return str.replace(/\W+/g, ' ')
    .split(/ |\B(?=[A-Z])/).map(word => word.toLowerCase()).join('-')
}

function toConstantCase(str) {
  return toSnakeCase(str).toUpperCase()
}

function toDotCase(str) {
  return str.replace(/\W+/g, ' ')
    .split(/ |\B(?=[A-Z])/).map(word => word.toLowerCase()).join('.')
}

function toPathCase(str) {
  return str.replace(/\W+/g, ' ')
    .split(/ |\B(?=[A-Z])/).map(word => word.toLowerCase()).join('/')
}

function toSentenceCase(str) {
  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()
}

function toTitleCase(str) {
  return str.replace(/\w\S*/g, (txt) => {
    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()
  })
}

// 转义函数
function escapeJava(str) {
  return str.replace(/\\/g, '\\\\')
    .replace(/"/g, '\\"')
    .replace(/'/g, "\\'") 
    .replace(/\n/g, '\\n')
    .replace(/\r/g, '\\r')
    .replace(/\t/g, '\\t')
}

function unescapeJava(str) {
  return str.replace(/\\\\/g, '\\')
    .replace(/\\"/g, '"')
    .replace(/\\'/g, "'")
    .replace(/\\n/g, '\n')
    .replace(/\\r/g, '\r')
    .replace(/\\t/g, '\t')
}

function escapeJavaScript(str) {
  return escapeJava(str)
}

function unescapeJavaScript(str) {
  return unescapeJava(str)
}

function escapeHtml(str) {
  return str.replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#39;')
}

function unescapeHtml(str) {
  return str.replace(/&amp;/g, '&')
    .replace(/&lt;/g, '<')
    .replace(/&gt;/g, '>')
    .replace(/&quot;/g, '"')
    .replace(/&#39;/g, "'")
}

function escapeJson(str) {
  return JSON.stringify(str)
}

function unescapeJson(str) {
  try {
    return JSON.parse(str)
  } catch (e) {
    return '解析失败：无效的JSON格式'
  }
}

function escapeXml(str) {
  return escapeHtml(str)
}

function unescapeXml(str) {
  return unescapeHtml(str)
}

function escapeUnicode(str) {
  return str.replace(/[\u0080-\uFFFF]/g, (match) => {
    return '\\u' + ('0000' + match.charCodeAt(0).toString(16)).substr(-4)
  })
}

function unescapeUnicode(str) {
  return str.replace(/\\u[0-9a-fA-F]{4}/g, (match) => {
    return String.fromCharCode(parseInt(match.replace(/\\u/g, ''), 16))
  })
}

// 哈希函数实现
function hashMd5(str) {
  return CryptoJS.MD5(str).toString()
}

function hashSha1(str) {
  return CryptoJS.SHA1(str).toString()
}

function hashSha256(str) {
  return CryptoJS.SHA256(str).toString()
}

function hashSha512(str) {
  return CryptoJS.SHA512(str).toString()
}

// 数字处理函数
function incrementNumbers(str) {
  return str.replace(/\d+/g, (match) => {
    return (parseInt(match) + 1).toString()
  })
}

function decrementNumbers(str) {
  return str.replace(/\d+/g, (match) => {
    return Math.max(0, parseInt(match) - 1).toString()
  })
}

function createSequence(str) {
  const lines = str.split('\n')
  return lines.map((line, index) => `${index + 1}. ${line}`).join('\n')
}

// 排序函数
function shuffleArray(array) {
  const newArray = [...array]
  for (let i = newArray.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1))
    ;[newArray[i], newArray[j]] = [newArray[j], newArray[i]]
  }
  return newArray
}

function sortJson(str) {
  try {
    const obj = JSON.parse(str)
    const sortedObj = sortObjectKeys(obj)
    return JSON.stringify(sortedObj, null, 2)
  } catch (e) {
    return '解析失败：无效的JSON格式'
  }
}

function sortObjectKeys(obj) {
  if (Array.isArray(obj)) {
    return obj.map(sortObjectKeys)
  } else if (obj !== null && typeof obj === 'object') {
    const sorted = {}
    Object.keys(obj).sort().forEach(key => {
      sorted[key] = sortObjectKeys(obj[key])
    })
    return sorted
  }
  return obj
}

// 对齐函数
function alignLeft(str) {
  return str.split('\n').map(line => line.trimStart()).join('\n')
}

function alignCenter(str) {
  const lines = str.split('\n')
  const maxLength = Math.max(...lines.map(line => line.trim().length))
  return lines.map(line => {
    const trimmed = line.trim()
    const padding = Math.max(0, Math.floor((maxLength - trimmed.length) / 2))
    return ' '.repeat(padding) + trimmed
  }).join('\n')
}

function alignRight(str) {
  const lines = str.split('\n')
  const maxLength = Math.max(...lines.map(line => line.trim().length))
  return lines.map(line => {
    const trimmed = line.trim()
    const padding = Math.max(0, maxLength - trimmed.length)
    return ' '.repeat(padding) + trimmed
  }).join('\n')
}

// 其他函数
function swapQuotes(str) {
  return str.replace(/["']/g, (match) => {
    return match === '"' ? "'" : '"'
  })
}